
声明 模块 "crypto" {

    //@@{ 流:stream }
    导入 * 转为 流 来自 "stream";

    //@@{ 证书_:Certificate }
    接口 证书_ {

        //@@{ 输出关联编码:exportChallenge, 二进制族_:BinaryLike, 缓冲区_:Buffer }
        输出关联编码(spkac: 二进制族_): 缓冲区_;

        //@@{ 输出公钥:exportPublicKey, 二进制族_:BinaryLike, 缓冲区_:Buffer }
        输出公钥(spkac: 二进制族_): 缓冲区_;

        //@@{ 验证Spkac:verifySpkac, 二进制_:Binary }
        验证Spkac(spkac: 二进制_): 真假;
    }

    //@@{ 证书_:Certificate }
    常量 证书_: {

        //@@{ 证书_:Certificate }
        新建(): 证书_;

        //@@{ 证书_:Certificate }
        (): 证书_;
    };

    //@@{ 常量组:constants }
    名域 常量组 { // https://nodejs.org/dist/latest-v10.x/docs/api/crypto.html#crypto_crypto_constants

        //@@{ __开放_版本_号__:OPENSSL_VERSION_NUMBER }
        常量 __开放_版本_号__: 数字;

        /** Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail. */

        //@@{ __SSL_选项_所有__:SSL_OP_ALL }
        常量 __SSL_选项_所有__: 数字;
        /** Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */

        //@@{ __SSL_选项_允许_不安全的_遗产_重新谈判__:SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION }
        常量 __SSL_选项_允许_不安全的_遗产_重新谈判__: 数字;
        /** Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */

        //@@{ __SSL_选项_密码_服务器_偏好__:SSL_OP_CIPHER_SERVER_PREFERENCE }
        常量 __SSL_选项_密码_服务器_偏好__: 数字;
        /** Instructs OpenSSL to use Cisco's "speshul" version of DTLS_BAD_VER. */

        //@@{ __SSL_选项_思科_任何连接__:SSL_OP_CISCO_ANYCONNECT }
        常量 __SSL_选项_思科_任何连接__: 数字;
        /** Instructs OpenSSL to turn on cookie exchange. */

        //@@{ __SSL_选项_浏览器缓存_交换__:SSL_OP_COOKIE_EXCHANGE }
        常量 __SSL_选项_浏览器缓存_交换__: 数字;
        /** Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft. */

        //@@{ __SSL_选项_密码支持_TLSEXT_错误__:SSL_OP_CRYPTOPRO_TLSEXT_BUG }
        常量 __SSL_选项_密码支持_TLSEXT_错误__: 数字;
        /** Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d. */

        //@@{ __SSL_选项_不_插入_空_片段__:SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS }
        常量 __SSL_选项_不_插入_空_片段__: 数字;
        /** Instructs OpenSSL to always use the tmp_rsa key when performing RSA operations. */

        //@@{ __SSL_选项_短暂的_RSA__:SSL_OP_EPHEMERAL_RSA }
        常量 __SSL_选项_短暂的_RSA__: 数字;
        /** Allows initial connection to servers that do not support RI. */

        //@@{ __SSL_选项_遗产_服务器_连接__:SSL_OP_LEGACY_SERVER_CONNECT }
        常量 __SSL_选项_遗产_服务器_连接__: 数字;

        //@@{ __SSL_选项_微软_大_SSLV3_缓冲__:SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER }
        常量 __SSL_选项_微软_大_SSLV3_缓冲__: 数字;

        //@@{ __SSL_选项_微软_捐_ID_错误__:SSL_OP_MICROSOFT_SESS_ID_BUG }
        常量 __SSL_选项_微软_捐_ID_错误__: 数字;
        /** Instructs OpenSSL to disable the workaround for a man-in-the-middle protocol-version vulnerability in the SSL 2.0 server implementation. */

        //@@{ __SSL_选项_MSIE_SSLV2_RSA_填充__:SSL_OP_MSIE_SSLV2_RSA_PADDING }
        常量 __SSL_选项_MSIE_SSLV2_RSA_填充__: 数字;

        //@@{ __SSL_选项_网景_CA_DN_错误__:SSL_OP_NETSCAPE_CA_DN_BUG }
        常量 __SSL_选项_网景_CA_DN_错误__: 数字;

        //@@{ __SSL_选项_网景_挑战_错误__:SSL_OP_NETSCAPE_CHALLENGE_BUG }
        常量 __SSL_选项_网景_挑战_错误__: 数字;

        //@@{ __SSL_选项_网景_演示_密码_改变_错误__:SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG }
        常量 __SSL_选项_网景_演示_密码_改变_错误__: 数字;

        //@@{ __SSL_选项_网景_重用_密码_改变_错误__:SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG }
        常量 __SSL_选项_网景_重用_密码_改变_错误__: 数字;
        /** Instructs OpenSSL to disable support for SSL/TLS compression. */

        //@@{ __SSL_选项_没有_压缩__:SSL_OP_NO_COMPRESSION }
        常量 __SSL_选项_没有_压缩__: 数字;

        //@@{ __SSL_选项_没有_查询_MTU__:SSL_OP_NO_QUERY_MTU }
        常量 __SSL_选项_没有_查询_MTU__: 数字;
        /** Instructs OpenSSL to always start a new session when performing renegotiation. */

        //@@{ __SSL_选项_没有_会话_恢复_在_重新谈判__:SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION }
        常量 __SSL_选项_没有_会话_恢复_在_重新谈判__: 数字;

        //@@{ SSL_选项_没有_SSLv2_:SSL_OP_NO_SSLv2 }
        常量 SSL_选项_没有_SSLv2_: 数字;

        //@@{ SSL_选项_没有_SSLv3_:SSL_OP_NO_SSLv3 }
        常量 SSL_选项_没有_SSLv3_: 数字;

        //@@{ __SSL_选项_没有_门票__:SSL_OP_NO_TICKET }
        常量 __SSL_选项_没有_门票__: 数字;

        //@@{ SSL_选项_没有_TLSv1_:SSL_OP_NO_TLSv1 }
        常量 SSL_选项_没有_TLSv1_: 数字;

        //@@{ SSL_选项_没有_TLSv1_1_:SSL_OP_NO_TLSv1_1 }
        常量 SSL_选项_没有_TLSv1_1_: 数字;

        //@@{ SSL_选项_没有_TLSv1_2_:SSL_OP_NO_TLSv1_2 }
        常量 SSL_选项_没有_TLSv1_2_: 数字;

        //@@{ __SSL_选项_PKCS1_检查_1__:SSL_OP_PKCS1_CHECK_1 }
        常量 __SSL_选项_PKCS1_检查_1__: 数字;

        //@@{ __SSL_选项_PKCS1_检查_2__:SSL_OP_PKCS1_CHECK_2 }
        常量 __SSL_选项_PKCS1_检查_2__: 数字;
        /** Instructs OpenSSL to always create a new key when using temporary/ephemeral DH parameters. */

        //@@{ __SSL_选项_单_DH_使用__:SSL_OP_SINGLE_DH_USE }
        常量 __SSL_选项_单_DH_使用__: 数字;
        /** Instructs OpenSSL to always create a new key when using temporary/ephemeral ECDH parameters. */

        //@@{ __SSL_选项_单_ECDH_使用__:SSL_OP_SINGLE_ECDH_USE }
        常量 __SSL_选项_单_ECDH_使用__: 数字;

        //@@{ __SSL_选项_SSLEAY_080_客户_DH_错误__:SSL_OP_SSLEAY_080_CLIENT_DH_BUG }
        常量 __SSL_选项_SSLEAY_080_客户_DH_错误__: 数字;

        //@@{ __SSL_选项_SSLREF2_重用_CERT_类型_错误__:SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG }
        常量 __SSL_选项_SSLREF2_重用_CERT_类型_错误__: 数字;

        //@@{ __SSL_选项_TLS_块_填充_错误__:SSL_OP_TLS_BLOCK_PADDING_BUG }
        常量 __SSL_选项_TLS_块_填充_错误__: 数字;

        //@@{ __SSL_选项_TLS_D5_错误__:SSL_OP_TLS_D5_BUG }
        常量 __SSL_选项_TLS_D5_错误__: 数字;
        /** Instructs OpenSSL to disable version rollback attack detection. */

        //@@{ __SSL_选项_TLS_回滚_错误__:SSL_OP_TLS_ROLLBACK_BUG }
        常量 __SSL_选项_TLS_回滚_错误__: 数字;

        //@@{ __引擎_方法_RSA__:ENGINE_METHOD_RSA }
        常量 __引擎_方法_RSA__: 数字;

        //@@{ __引擎_方法_DSA__:ENGINE_METHOD_DSA }
        常量 __引擎_方法_DSA__: 数字;

        //@@{ __引擎_方法_DH__:ENGINE_METHOD_DH }
        常量 __引擎_方法_DH__: 数字;

        //@@{ __引擎_方法_RAND__:ENGINE_METHOD_RAND }
        常量 __引擎_方法_RAND__: 数字;

        //@@{ __发动机_方法_EC__:ENGINE_METHOD_EC }
        常量 __发动机_方法_EC__: 数字;

        //@@{ __引擎_方法_密码__:ENGINE_METHOD_CIPHERS }
        常量 __引擎_方法_密码__: 数字;

        //@@{ __引擎_方法_摘要__:ENGINE_METHOD_DIGESTS }
        常量 __引擎_方法_摘要__: 数字;

        //@@{ __引擎_方法_PKEY_METHS__:ENGINE_METHOD_PKEY_METHS }
        常量 __引擎_方法_PKEY_METHS__: 数字;

        //@@{ __引擎_方法_PKEY_ASN1_METHS__:ENGINE_METHOD_PKEY_ASN1_METHS }
        常量 __引擎_方法_PKEY_ASN1_METHS__: 数字;

        //@@{ __引擎_方法_所有__:ENGINE_METHOD_ALL }
        常量 __引擎_方法_所有__: 数字;

        //@@{ __引擎_方法_没有__:ENGINE_METHOD_NONE }
        常量 __引擎_方法_没有__: 数字;

        //@@{ __DH_检查_P_不_安全_首要的__:DH_CHECK_P_NOT_SAFE_PRIME }
        常量 __DH_检查_P_不_安全_首要的__: 数字;

        //@@{ __DH_检查_P_不_首要的__:DH_CHECK_P_NOT_PRIME }
        常量 __DH_检查_P_不_首要的__: 数字;

        //@@{ __DH_不能_来_检查_引擎__:DH_UNABLE_TO_CHECK_GENERATOR }
        常量 __DH_不能_来_检查_引擎__: 数字;

        //@@{ __DH_不_合适的_引擎__:DH_NOT_SUITABLE_GENERATOR }
        常量 __DH_不_合适的_引擎__: 数字;

        //@@{ __ALPN_启用__:ALPN_ENABLED }
        常量 __ALPN_启用__: 数字;

        //@@{ __RSA_PKCS1_填充__:RSA_PKCS1_PADDING }
        常量 __RSA_PKCS1_填充__: 数字;

        //@@{ __RSA_SSLV23_填充__:RSA_SSLV23_PADDING }
        常量 __RSA_SSLV23_填充__: 数字;

        //@@{ __RSA_没有_填充__:RSA_NO_PADDING }
        常量 __RSA_没有_填充__: 数字;

        //@@{ __RSA_PKCS1_OAEP_填充__:RSA_PKCS1_OAEP_PADDING }
        常量 __RSA_PKCS1_OAEP_填充__: 数字;

        //@@{ __RSA_X931_填充__:RSA_X931_PADDING }
        常量 __RSA_X931_填充__: 数字;

        //@@{ __RSA_PKCS1_PSS_填充__:RSA_PKCS1_PSS_PADDING }
        常量 __RSA_PKCS1_PSS_填充__: 数字;
        /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying. */

        //@@{ __RSA_PSS_盐长度_文摘__:RSA_PSS_SALTLEN_DIGEST }
        常量 __RSA_PSS_盐长度_文摘__: 数字;
        /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data. */

        //@@{ __RSA_PSS_盐长度_最大_信号__:RSA_PSS_SALTLEN_MAX_SIGN }
        常量 __RSA_PSS_盐长度_最大_信号__: 数字;
        /** Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature. */

        //@@{ __RSA_PSS_盐长度_自动__:RSA_PSS_SALTLEN_AUTO }
        常量 __RSA_PSS_盐长度_自动__: 数字;

        //@@{ __点_转换_压缩__:POINT_CONVERSION_COMPRESSED }
        常量 __点_转换_压缩__: 数字;

        //@@{ __点_转换_不压缩__:POINT_CONVERSION_UNCOMPRESSED }
        常量 __点_转换_不压缩__: 数字;

        //@@{ __点_转换_混合__:POINT_CONVERSION_HYBRID }
        常量 __点_转换_混合__: 数字;

        /** Specifies the built-in default cipher list used by Node.js (colon-separated values). */

        //@@{ 默认核心密码列表:defaultCoreCipherList }
        常量 默认核心密码列表: 文字;
        /** Specifies the active default cipher list used by the current Node.js process  (colon-separated values). */

        //@@{ 默认密码列表:defaultCipherList }
        常量 默认密码列表: 文字;
    }

    /** @deprecated since v10.0.0 */
    常量 fips: 真假;

    //@@{ 创建哈希:createHash, 流:stream, 变换选项_:TransformOptions, 哈希_:Hash }
    函数 创建哈希(算法: 文字, 选项组?: 流.变换选项_): 哈希_;

    //@@{ 创建Hmac:createHmac, 二进制族_:BinaryLike, 流:stream, 变换选项_:TransformOptions }
    函数 创建Hmac(算法: 文字, key: 二进制族_, 选项组?: 流.变换选项_): Hmac;

    //@@{ Utf8Ascii编码_:Utf8AsciiLatin1Encoding }
    类型 Utf8Ascii编码_ = "utf8" | "ascii" | "latin1";

    //@@{ HexBase64编码_:HexBase64Latin1Encoding }
    类型 HexBase64编码_ = "latin1" | "hex" | "base64";

    //@@{ Utf8Ascii二进制编码_:Utf8AsciiBinaryEncoding }
    类型 Utf8Ascii二进制编码_ = "utf8" | "ascii" | "binary";

    //@@{ HexBase64二进制编码_:HexBase64BinaryEncoding }
    类型 HexBase64二进制编码_ = "binary" | "base64" | "hex";

    //@@{ ECDH密钥格式_:ECDHKeyFormat, "压缩":"compressed", "未压缩":"uncompressed" }
    //@@{ "混合":"hybrid" }
    类型 ECDH密钥格式_ = "压缩" | "未压缩" | "混合";

    //@@{ 哈希_:Hash, 流:stream, 双工_:Duplex }
    类别 哈希_ 扩展 流.双工_ {
        私有 构造();

        //@@{ 更新:update, 二进制族_:BinaryLike, 哈希_:Hash }
        更新(数据: 二进制族_): 哈希_;

        //@@{ 更新:update, Utf8Ascii编码_:Utf8AsciiLatin1Encoding, 哈希_:Hash }
        更新(数据: 文字, 输入_编码: Utf8Ascii编码_): 哈希_;

        //@@{ 摘要:digest, 缓冲区_:Buffer }
        摘要(): 缓冲区_;

        //@@{ 摘要:digest, HexBase64编码_:HexBase64Latin1Encoding }
        摘要(编码: HexBase64编码_): 文字;
    }

    //@@{ 流:stream, 双工_:Duplex }
    类别 Hmac 扩展 流.双工_ {
        私有 构造();

        //@@{ 更新:update, 二进制族_:BinaryLike }
        更新(数据: 二进制族_): Hmac;

        //@@{ 更新:update, Utf8Ascii编码_:Utf8AsciiLatin1Encoding }
        更新(数据: 文字, 输入_编码: Utf8Ascii编码_): Hmac;

        //@@{ 摘要:digest, 缓冲区_:Buffer }
        摘要(): 缓冲区_;

        //@@{ 摘要:digest, HexBase64编码_:HexBase64Latin1Encoding }
        摘要(编码: HexBase64编码_): 文字;
    }

    //@@{ 密钥对象类型_:KeyObjectType, "私密":"secret", "公开":"public", "私有":"private" }
    导出 类型 密钥对象类型_ = "私密" | "公开" | "私有";

    //@@{ 密钥导出选项_:KeyExportOptions, 密钥格式化_:KeyFormat }
    接口 密钥导出选项_<T 扩展 密钥格式化_> {

        //@@{ 类型:type }
        类型: 'pkcs1' | 'spki' | 'pkcs8' | 'sec1';

        //@@{ 格式化:format }
        格式化: T;

        //@@{ 密码:cipher }
        密码?: 文字;

        //@@{ 口令:passphrase, 缓冲区_:Buffer }
        口令?: 文字 | 缓冲区_;
    }

    //@@{ 密钥对象_:KeyObject }
    类别 密钥对象_ {
        私有 构造();

        //@@{ 非对称密钥类型:asymmetricKeyType, 密钥类型_:KeyType }
        非对称密钥类型?: 密钥类型_;

        //@@{ 导出:export, 密钥导出选项_:KeyExportOptions, 缓冲区_:Buffer }
        导出(选项组: 密钥导出选项_<'pem'>): 文字 | 缓冲区_;

        //@@{ 导出:export, 密钥导出选项_:KeyExportOptions, 缓冲区_:Buffer }
        导出(选项组?: 密钥导出选项_<'der'>): 缓冲区_;

        //@@{ 对称尺寸:symmetricSize }
        对称尺寸?: 数字;

        //@@{ 类型:type, 密钥对象类型_:KeyObjectType }
        类型: 密钥对象类型_;
    }

    //@@{ 密码CCM类型_:CipherCCMTypes }
    类型 密码CCM类型_ = 'aes-128-ccm' | 'aes-192-ccm' | 'aes-256-ccm';

    //@@{ 密码GCM类型_:CipherGCMTypes }
    类型 密码GCM类型_ = 'aes-128-gcm' | 'aes-192-gcm' | 'aes-256-gcm';

    //@@{ 二进制_:Binary, 缓冲区_:Buffer, 类型数组_:TypedArray, 数据视图_:DataView }
    类型 二进制_ = 缓冲区_ | NodeJS.类型数组_ | 数据视图_;

    //@@{ 二进制族_:BinaryLike, 二进制_:Binary }
    类型 二进制族_ = 文字 | 二进制_;

    //@@{ 密码密钥_:CipherKey, 二进制族_:BinaryLike, 密钥对象_:KeyObject }
    类型 密码密钥_ = 二进制族_ | 密钥对象_;

    //@@{ 密码CCM选项_:CipherCCMOptions, 流:stream, 变换选项_:TransformOptions }
    接口 密码CCM选项_ 扩展 流.变换选项_ {

        //@@{ Auth标签长度:authTagLength }
        Auth标签长度: 数字;
    }

    //@@{ 密码GCM选项_:CipherGCMOptions, 流:stream, 变换选项_:TransformOptions }
    接口 密码GCM选项_ 扩展 流.变换选项_ {

        //@@{ Auth标签长度:authTagLength }
        Auth标签长度?: 数字;
    }
    /** @deprecated since v10.0.0 use createCipheriv() */

    //@@{ 创建加密者:createCipher, 密码CCM类型_:CipherCCMTypes, 二进制族_:BinaryLike, 密码CCM选项_:CipherCCMOptions }
    //@@{ 密码CCM_:CipherCCM }
    函数 创建加密者(算法: 密码CCM类型_, 密码: 二进制族_, 选项组: 密码CCM选项_): 密码CCM_;
    /** @deprecated since v10.0.0 use createCipheriv() */

    //@@{ 创建加密者:createCipher, 密码GCM类型_:CipherGCMTypes, 二进制族_:BinaryLike, 密码GCM选项_:CipherGCMOptions }
    //@@{ 密码GCM_:CipherGCM }
    函数 创建加密者(算法: 密码GCM类型_, 密码: 二进制族_, 选项组?: 密码GCM选项_): 密码GCM_;
    /** @deprecated since v10.0.0 use createCipheriv() */

    //@@{ 创建加密者:createCipher, 二进制族_:BinaryLike, 流:stream, 变换选项_:TransformOptions }
    //@@{ 加密者_:Cipher }
    函数 创建加密者(算法: 文字, 密码: 二进制族_, 选项组?: 流.变换选项_): 加密者_;

    //@@{ 创建加密者指定密钥及初始向量:createCipheriv }
    函数 创建加密者指定密钥及初始向量(

        //@@{ 密码CCM类型_:CipherCCMTypes }
        算法: 密码CCM类型_,

        //@@{ 密码密钥_:CipherKey }
        密钥: 密码密钥_,

        //@@{ 二进制族_:BinaryLike }
        初始向量: 二进制族_ | 空值,

        //@@{ 密码CCM选项_:CipherCCMOptions }
        选项组: 密码CCM选项_

    //@@{ 密码CCM_:CipherCCM }
    ): 密码CCM_;

    //@@{ 创建加密者指定密钥及初始向量:createCipheriv }
    函数 创建加密者指定密钥及初始向量(

        //@@{ 密码GCM类型_:CipherGCMTypes }
        算法: 密码GCM类型_,

        //@@{ 密码密钥_:CipherKey }
        密钥: 密码密钥_,

        //@@{ 二进制族_:BinaryLike }
        初始向量: 二进制族_ | 空值,

        //@@{ 密码GCM选项_:CipherGCMOptions }
        选项组?: 密码GCM选项_

    //@@{ 密码GCM_:CipherGCM }
    ): 密码GCM_;

    //@@{ 创建加密者指定密钥及初始向量:createCipheriv }
    函数 创建加密者指定密钥及初始向量(

        //@@{ 密码密钥_:CipherKey, 二进制族_:BinaryLike, 流:stream, 变换选项_:TransformOptions }
        算法: 文字, 密钥: 密码密钥_, 初始向量: 二进制族_ | 空值, 选项组?: 流.变换选项_

    //@@{ 加密者_:Cipher }
    ): 加密者_;

    //@@{ 加密者_:Cipher, 流:stream, 双工_:Duplex }
    类别 加密者_ 扩展 流.双工_ {
        私有 构造();

        //@@{ 更新:update, 二进制族_:BinaryLike, 缓冲区_:Buffer }
        更新(数据: 二进制族_): 缓冲区_;

        //@@{ 更新:update, Utf8Ascii二进制编码_:Utf8AsciiBinaryEncoding, 缓冲区_:Buffer }
        更新(数据: 文字, 输入_编码: Utf8Ascii二进制编码_): 缓冲区_;

        //@@{ 更新:update, 二进制_:Binary, HexBase64二进制编码_:HexBase64BinaryEncoding }
        更新(数据: 二进制_, 输入_编码: 未定, 输出_编码: HexBase64二进制编码_): 文字;

        //@@{ 更新:update, Utf8Ascii二进制编码_:Utf8AsciiBinaryEncoding, HexBase64二进制编码_:HexBase64BinaryEncoding }
        更新(数据: 文字, 输入_编码: Utf8Ascii二进制编码_ | 未定, 输出_编码: HexBase64二进制编码_): 文字;

        //@@{ 最后:final, 缓冲区_:Buffer }
        最后(): 缓冲区_;

        //@@{ 最后:final }
        最后(输出_编码: 文字): 文字;

        //@@{ 设置自动填充:setAutoPadding }
        设置自动填充(自动_填充?: 真假): 本体;
        // getAuthTag(): Buffer;
        // setAAD(buffer: Buffer): this; // docs only say buffer
    }

    //@@{ 密码CCM_:CipherCCM, 加密者_:Cipher }
    接口 密码CCM_ 扩展 加密者_ {

        //@@{ 设置认证数据AAD:setAAD, 缓冲区_:Buffer, 纯文本长度:plaintextLength }
        设置认证数据AAD(缓冲区: 缓冲区_, 选项组: { 纯文本长度: 数字 }): 本体;

        //@@{ 获取身份验证标签:getAuthTag, 缓冲区_:Buffer }
        获取身份验证标签(): 缓冲区_;
    }

    //@@{ 密码GCM_:CipherGCM, 加密者_:Cipher }
    接口 密码GCM_ 扩展 加密者_ {

        //@@{ 设置认证数据AAD:setAAD, 缓冲区_:Buffer, 纯文本长度:plaintextLength }
        设置认证数据AAD(缓冲区: 缓冲区_, 选项组?: { 纯文本长度: 数字 }): 本体;

        //@@{ 获取身份验证标签:getAuthTag, 缓冲区_:Buffer }
        获取身份验证标签(): 缓冲区_;
    }
    /** @deprecated since v10.0.0 use createCipheriv() */

    //@@{ 创建破译者:createDecipher, 密码CCM类型_:CipherCCMTypes, 二进制族_:BinaryLike }
    //@@{ 密码CCM选项_:CipherCCMOptions, 破译CCM_:DecipherCCM }
    函数 创建破译者(算法: 密码CCM类型_, 密码: 二进制族_, 选项组: 密码CCM选项_): 破译CCM_;
    /** @deprecated since v10.0.0 use createCipheriv() */

    //@@{ 创建破译者:createDecipher, 密码GCM类型_:CipherGCMTypes, 二进制族_:BinaryLike }
    //@@{ 密码GCM选项_:CipherGCMOptions, 破译GCM_:DecipherGCM }
    函数 创建破译者(算法: 密码GCM类型_, 密码: 二进制族_, 选项组?: 密码GCM选项_): 破译GCM_;
    /** @deprecated since v10.0.0 use createCipheriv() */

    //@@{ 创建破译者:createDecipher, 二进制族_:BinaryLike, 流:stream, 变换选项_:TransformOptions }
    //@@{ 破译者_:Decipher }
    函数 创建破译者(算法: 文字, 密码: 二进制族_, 选项组?: 流.变换选项_): 破译者_;

    //@@{ 创建破译者指定密钥及初始向量:createDecipheriv }
    函数 创建破译者指定密钥及初始向量(

        //@@{ 密码CCM类型_:CipherCCMTypes }
        算法: 密码CCM类型_,

        //@@{ 二进制族_:BinaryLike }
        密钥: 二进制族_,

        //@@{ 二进制族_:BinaryLike }
        初始向量: 二进制族_ | 空值,

        //@@{ 密码CCM选项_:CipherCCMOptions }
        选项组: 密码CCM选项_,

    //@@{ 破译CCM_:DecipherCCM }
    ): 破译CCM_;

    //@@{ 创建破译者指定密钥及初始向量:createDecipheriv }
    函数 创建破译者指定密钥及初始向量(

        //@@{ 密码GCM类型_:CipherGCMTypes }
        算法: 密码GCM类型_,

        //@@{ 二进制族_:BinaryLike }
        密钥: 二进制族_,

        //@@{ 二进制族_:BinaryLike }
        初始向量: 二进制族_ | 空值,

        //@@{ 密码GCM选项_:CipherGCMOptions }
        选项组?: 密码GCM选项_,

    //@@{ 破译GCM_:DecipherGCM }
    ): 破译GCM_;

    //@@{ 创建破译者指定密钥及初始向量:createDecipheriv, 二进制族_:BinaryLike, 流:stream, 变换选项_:TransformOptions }
    //@@{ 破译者_:Decipher }
    函数 创建破译者指定密钥及初始向量(算法: 文字, key: 二进制族_, 初始向量: 二进制族_ | 空值, 选项组?: 流.变换选项_): 破译者_;

    //@@{ 破译者_:Decipher, 流:stream, 双工_:Duplex }
    类别 破译者_ 扩展 流.双工_ {
        私有 构造();

        //@@{ 更新:update, 二进制_:Binary, 缓冲区_:Buffer }
        更新(数据: 二进制_): 缓冲区_;

        //@@{ 更新:update, HexBase64二进制编码_:HexBase64BinaryEncoding, 缓冲区_:Buffer }
        更新(数据: 文字, 输入_编码: HexBase64二进制编码_): 缓冲区_;

        //@@{ 更新:update, 二进制_:Binary, Utf8Ascii二进制编码_:Utf8AsciiBinaryEncoding }
        更新(数据: 二进制_, 输入_编码: 未定, 输出_编码: Utf8Ascii二进制编码_): 文字;

        //@@{ 更新:update, HexBase64二进制编码_:HexBase64BinaryEncoding, Utf8Ascii二进制编码_:Utf8AsciiBinaryEncoding }
        更新(数据: 文字, 输入_编码: HexBase64二进制编码_ | 未定, 输出_编码: Utf8Ascii二进制编码_): 文字;

        //@@{ 最后:final, 缓冲区_:Buffer }
        最后(): 缓冲区_;

        //@@{ 最后:final }
        最后(输出_编码: 文字): 文字;

        //@@{ 设置自动填充:setAutoPadding }
        设置自动填充(自动_填充?: 真假): 本体;
        // setAuthTag(tag: Binary): this;
        // setAAD(buffer: Binary): this;
    }

    //@@{ 破译CCM_:DecipherCCM, 破译者_:Decipher }
    接口 破译CCM_ 扩展 破译者_ {

        //@@{ 设置身份验证标签:setAuthTag, 二进制_:Binary }
        设置身份验证标签(缓冲区: 二进制_): 本体;

        //@@{ 设置认证数据AAD:setAAD, 二进制_:Binary, 纯文本长度:plaintextLength }
        设置认证数据AAD(缓冲区: 二进制_, 选项组: { 纯文本长度: 数字 }): 本体;
    }

    //@@{ 破译GCM_:DecipherGCM, 破译者_:Decipher }
    接口 破译GCM_ 扩展 破译者_ {

        //@@{ 设置身份验证标签:setAuthTag, 二进制_:Binary }
        设置身份验证标签(缓冲区: 二进制_): 本体;

        //@@{ 设置认证数据AAD:setAAD, 二进制_:Binary, 纯文本长度:plaintextLength }
        设置认证数据AAD(缓冲区: 二进制_, 选项组?: { 纯文本长度: 数字 }): 本体;
    }

    //@@{ 私钥输入_:PrivateKeyInput }
    接口 私钥输入_ {

        //@@{ 密钥:key, 缓冲区_:Buffer }
        密钥: 文字 | 缓冲区_;

        //@@{ 格式化:format, 密钥格式化_:KeyFormat }
        格式化?: 密钥格式化_;

        //@@{ 类型:type }
        类型?: 'pkcs1' | 'pkcs8' | 'sec1';

        //@@{ 口令:passphrase, 缓冲区_:Buffer }
        口令?: 文字 | 缓冲区_;
    }

    //@@{ 公钥输入_:PublicKeyInput }
    接口 公钥输入_ {

        //@@{ 密钥:key, 缓冲区_:Buffer }
        密钥: 文字 | 缓冲区_;

        //@@{ 格式化:format, 密钥格式化_:KeyFormat }
        格式化?: 密钥格式化_;

        //@@{ 类型:type }
        类型?: 'pkcs1' | 'spki';
    }

    //@@{ 创建私钥:createPrivateKey, 私钥输入_:PrivateKeyInput, 缓冲区_:Buffer, 密钥对象_:KeyObject }
    函数 创建私钥(密钥: 私钥输入_ | 文字 | 缓冲区_): 密钥对象_;

    //@@{ 创建公钥:createPublicKey, 公钥输入_:PublicKeyInput, 缓冲区_:Buffer, 密钥对象_:KeyObject }
    函数 创建公钥(密钥: 公钥输入_ | 文字 | 缓冲区_ | 密钥对象_): 密钥对象_;

    //@@{ 创建密钥:createSecretKey, 缓冲区_:Buffer, 密钥对象_:KeyObject }
    函数 创建密钥(密钥: 缓冲区_): 密钥对象_;

    //@@{ 创建签名者:createSign, 流:stream, 可写的选项_:WritableOptions, 签名者_:Signer }
    函数 创建签名者(算法: 文字, 选项组?: 流.可写的选项_): 签名者_;

    //@@{ 签署私钥输入_:SignPrivateKeyInput, 私钥输入_:PrivateKeyInput }
    接口 签署私钥输入_ 扩展 私钥输入_ {

        //@@{ 填充:padding }
        填充?: 数字;

        //@@{ 盐长度:saltLength }
        盐长度?: 数字;
    }

    //@@{ 密钥族_:KeyLike, 缓冲区_:Buffer, 密钥对象_:KeyObject }
    类型 密钥族_ = 文字 | 缓冲区_ | 密钥对象_;

    //@@{ 签名者_:Signer, 流:stream, 可写的_:Writable }
    类别 签名者_ 扩展 流.可写的_ {
        私有 构造();

        //@@{ 更新:update, 二进制族_:BinaryLike, 签名者_:Signer }
        更新(数据: 二进制族_): 签名者_;

        //@@{ 更新:update, Utf8Ascii编码_:Utf8AsciiLatin1Encoding, 签名者_:Signer }
        更新(数据: 文字, 输入_编码: Utf8Ascii编码_): 签名者_;

        //@@{ 签名:sign, 签署私钥输入_:SignPrivateKeyInput, 密钥族_:KeyLike, 缓冲区_:Buffer }
        签名(私有_密钥: 签署私钥输入_ | 密钥族_): 缓冲区_;

        //@@{ 签名:sign, 签署私钥输入_:SignPrivateKeyInput, 密钥族_:KeyLike, HexBase64编码_:HexBase64Latin1Encoding }
        签名(私有_密钥: 签署私钥输入_ | 密钥族_, 输出_格式: HexBase64编码_): 文字;
    }

    //@@{ 创建验证者:createVerify, 流:stream, 可写的选项_:WritableOptions, 验证者_:Verify }
    函数 创建验证者(algorith: 文字, 选项组?: 流.可写的选项_): 验证者_;

    //@@{ 验证者_:Verify, 流:stream, 可写的_:Writable }
    类别 验证者_ 扩展 流.可写的_ {
        私有 构造();

        //@@{ 更新:update, 二进制族_:BinaryLike, 验证者_:Verify }
        更新(数据: 二进制族_): 验证者_;

        //@@{ 更新:update, Utf8Ascii编码_:Utf8AsciiLatin1Encoding, 验证者_:Verify }
        更新(数据: 文字, 输入_编码: Utf8Ascii编码_): 验证者_;

        //@@{ 验证:verify, 实例_:Object, 密钥族_:KeyLike, 二进制_:Binary }
        验证(对象: 实例_ | 密钥族_, 签名: 二进制_): 真假;

        //@@{ 验证:verify, 实例_:Object, 密钥族_:KeyLike, HexBase64编码_:HexBase64Latin1Encoding }
        验证(对象: 实例_ | 密钥族_, 签名: 文字, 签名_格式化?: HexBase64编码_): 真假;
        // https://nodejs.org/api/crypto.html#crypto_verifier_verify_object_signature_signature_format
        // The signature field accepts a TypedArray type, but it is only available starting ES2017
    }

    //@@{ 创建密钥交换DH:createDiffieHellman, 二进制_:Binary, 密钥交换DH_:DiffieHellman }
    函数 创建密钥交换DH(素数_长度: 数字, 引擎?: 数字 | 二进制_): 密钥交换DH_;

    //@@{ 创建密钥交换DH:createDiffieHellman, 二进制_:Binary, 密钥交换DH_:DiffieHellman }
    函数 创建密钥交换DH(首要的: 二进制_): 密钥交换DH_;

    //@@{ 创建密钥交换DH:createDiffieHellman, HexBase64编码_:HexBase64Latin1Encoding }
    //@@{ 密钥交换DH_:DiffieHellman }
    函数 创建密钥交换DH(首要的: 文字, 素数_编码: HexBase64编码_): 密钥交换DH_;

    //@@{ 创建密钥交换DH:createDiffieHellman, HexBase64编码_:HexBase64Latin1Encoding }
    //@@{ 二进制_:Binary, 密钥交换DH_:DiffieHellman }
    函数 创建密钥交换DH(首要的: 文字, 素数_编码: HexBase64编码_, 引擎: 数字 | 二进制_): 密钥交换DH_;

    //@@{ 创建密钥交换DH:createDiffieHellman, HexBase64编码_:HexBase64Latin1Encoding }
    //@@{ 密钥交换DH_:DiffieHellman }
    函数 创建密钥交换DH(首要的: 文字, 素数_编码: HexBase64编码_, 引擎: 文字, 引擎_编码: HexBase64编码_): 密钥交换DH_;

    //@@{ 密钥交换DH_:DiffieHellman }
    类别 密钥交换DH_ {
        私有 构造();

        //@@{ 生成密钥:generateKeys, 缓冲区_:Buffer }
        生成密钥(): 缓冲区_;

        //@@{ 生成密钥:generateKeys, HexBase64编码_:HexBase64Latin1Encoding }
        生成密钥(编码: HexBase64编码_): 文字;

        //@@{ 计算共享密钥:computeSecret, 二进制_:Binary, 缓冲区_:Buffer }
        计算共享密钥(其他_公共_密钥: 二进制_): 缓冲区_;

        //@@{ 计算共享密钥:computeSecret, HexBase64编码_:HexBase64Latin1Encoding, 缓冲区_:Buffer }
        计算共享密钥(其他_公共_密钥: 文字, 输入_编码: HexBase64编码_): 缓冲区_;

        //@@{ 计算共享密钥:computeSecret, 二进制_:Binary, HexBase64编码_:HexBase64Latin1Encoding }
        计算共享密钥(其他_公共_密钥: 二进制_, 输出_编码: HexBase64编码_): 文字;

        //@@{ 计算共享密钥:computeSecret, HexBase64编码_:HexBase64Latin1Encoding }
        计算共享密钥(其他_公共_密钥: 文字, 输入_编码: HexBase64编码_, 输出_编码: HexBase64编码_): 文字;

        //@@{ 获取素数:getPrime, 缓冲区_:Buffer }
        获取素数(): 缓冲区_;

        //@@{ 获取素数:getPrime, HexBase64编码_:HexBase64Latin1Encoding }
        获取素数(编码: HexBase64编码_): 文字;

        //@@{ 获取引擎:getGenerator, 缓冲区_:Buffer }
        获取引擎(): 缓冲区_;

        //@@{ 获取引擎:getGenerator, HexBase64编码_:HexBase64Latin1Encoding }
        获取引擎(编码: HexBase64编码_): 文字;

        //@@{ 获取公钥:getPublicKey, 缓冲区_:Buffer }
        获取公钥(): 缓冲区_;

        //@@{ 获取公钥:getPublicKey, HexBase64编码_:HexBase64Latin1Encoding }
        获取公钥(编码: HexBase64编码_): 文字;

        //@@{ 获取私钥:getPrivateKey, 缓冲区_:Buffer }
        获取私钥(): 缓冲区_;

        //@@{ 获取私钥:getPrivateKey, HexBase64编码_:HexBase64Latin1Encoding }
        获取私钥(编码: HexBase64编码_): 文字;

        //@@{ 设置公钥:setPublicKey, 二进制_:Binary }
        设置公钥(公共_密钥: 二进制_): 无值;

        //@@{ 设置公钥:setPublicKey }
        设置公钥(公共_密钥: 文字, 编码: 文字): 无值;

        //@@{ 设置私钥:setPrivateKey, 二进制_:Binary }
        设置私钥(私有_密钥: 二进制_): 无值;

        //@@{ 设置私钥:setPrivateKey }
        设置私钥(私有_密钥: 文字, 编码: 文字): 无值;

        //@@{ 验证错误:verifyError }
        验证错误: 数字;
    }

    //@@{ 获取密钥交换DH:getDiffieHellman, 密钥交换DH_:DiffieHellman }
    函数 获取密钥交换DH(集团_名字: 文字): 密钥交换DH_;

    //@@{ 基于口令密钥导出函数:pbkdf2 }
    函数 基于口令密钥导出函数(

        //@@{ 二进制族_:BinaryLike }
        密码: 二进制族_,

        //@@{ 二进制族_:BinaryLike }
        盐: 二进制族_,
        迭代: 数字,
        密钥长度: 数字,
        摘要: 文字,

        //@@{ 错误_:Error, 缓冲区_:Buffer }
        回调: (错: 错误_ | 空值, 派生密钥: 缓冲区_) => 任意,
    ): 无值;

    //@@{ 基于口令密钥导出函数同步:pbkdf2Sync, 二进制族_:BinaryLike, 缓冲区_:Buffer }
    函数 基于口令密钥导出函数同步(密码: 二进制族_, 盐: 二进制族_, 迭代: 数字, 密钥长度: 数字, 摘要: 文字): 缓冲区_;

    //@@{ 随机字节:randomBytes, 缓冲区_:Buffer }
    函数 随机字节(大小: 数字): 缓冲区_;

    //@@{ 随机字节:randomBytes, 错误_:Error, 缓冲区_:Buffer }
    函数 随机字节(大小: 数字, 回调: (错: 错误_ | 空值, 缓冲: 缓冲区_) => 无值): 无值;

    //@@{ 伪随机字节:pseudoRandomBytes, 缓冲区_:Buffer }
    函数 伪随机字节(大小: 数字): 缓冲区_;

    //@@{ 伪随机字节:pseudoRandomBytes, 错误_:Error, 缓冲区_:Buffer }
    函数 伪随机字节(大小: 数字, 回调: (错: 错误_ | 空值, 缓冲: 缓冲区_) => 无值): 无值;

    //@@{ 随机填充同步:randomFillSync, 二进制_:Binary }
    函数 随机填充同步<T 扩展 二进制_>(缓冲区: T, 偏移?: 数字, 大小?: 数字): T;

    //@@{ 随机填充:randomFill, 二进制_:Binary, 错误_:Error }
    函数 随机填充<T 扩展 二进制_>(缓冲区: T, 回调: (错: 错误_ | 空值, 缓冲: T) => 无值): 无值;

    //@@{ 随机填充:randomFill, 二进制_:Binary, 错误_:Error }
    函数 随机填充<T 扩展 二进制_>(缓冲区: T, 偏移: 数字, 回调: (错: 错误_ | 空值, 缓冲: T) => 无值): 无值;

    //@@{ 随机填充:randomFill, 二进制_:Binary, 错误_:Error }
    函数 随机填充<T 扩展 二进制_>(缓冲区: T, 偏移: 数字, 大小: 数字, 回调: (错: 错误_ | 空值, 缓冲: T) => 无值): 无值;

    //@@{ 加密选项_:ScryptOptions }
    接口 加密选项_ {
        N?: 数字;
        r?: 数字;
        p?: 数字;
        maxmem?: 数字;
    }

    //@@{ 解密:scrypt }
    函数 解密(

        //@@{ 二进制族_:BinaryLike }
        密码: 二进制族_,

        //@@{ 二进制族_:BinaryLike }
        盐: 二进制族_,

        //@@{ 错误_:Error, 缓冲区_:Buffer }
        密钥长度: 数字, 回调: (错: 错误_ | 空值, 派生密钥: 缓冲区_) => 无值,
    ): 无值;

    //@@{ 解密:scrypt }
    函数 解密(

        //@@{ 二进制族_:BinaryLike }
        密码: 二进制族_,

        //@@{ 二进制族_:BinaryLike }
        盐: 二进制族_,
        密钥长度: 数字,

        //@@{ 加密选项_:ScryptOptions }
        选项组: 加密选项_,

        //@@{ 错误_:Error, 缓冲区_:Buffer }
        回调: (错: 错误_ | 空值, 派生密钥: 缓冲区_) => 无值,
    ): 无值;

    //@@{ 同步扫描:scryptSync, 二进制族_:BinaryLike, 加密选项_:ScryptOptions, 缓冲区_:Buffer }
    函数 同步扫描(密码: 二进制族_, 盐: 二进制族_, 密钥长度: 数字, 选项组?: 加密选项_): 缓冲区_;

    //@@{ Rsa公钥_:RsaPublicKey }
    接口 Rsa公钥_ {

        //@@{ 密钥族_:KeyLike }
        key: 密钥族_;

        //@@{ 填充:padding }
        填充?: 数字;
    }

    //@@{ Rsa私钥_:RsaPrivateKey }
    接口 Rsa私钥_ {

        //@@{ 密钥:key, 密钥族_:KeyLike }
        密钥: 密钥族_;

        //@@{ 口令:passphrase }
        口令?: 文字;

        //@@{ 填充:padding }
        填充?: 数字;
    }

    //@@{ 公共加密:publicEncrypt, Rsa公钥_:RsaPublicKey, 密钥族_:KeyLike, 二进制_:Binary }
    //@@{ 缓冲区_:Buffer }
    函数 公共加密(公共_密钥: Rsa公钥_ | 密钥族_, 缓冲区: 二进制_): 缓冲区_;

    //@@{ 私有解密:privateDecrypt, Rsa私钥_:RsaPrivateKey, 密钥族_:KeyLike, 二进制_:Binary }
    //@@{ 缓冲区_:Buffer }
    函数 私有解密(私有_密钥: Rsa私钥_ | 密钥族_, 缓冲区: 二进制_): 缓冲区_;

    //@@{ 私有加密:privateEncrypt, Rsa私钥_:RsaPrivateKey, 密钥族_:KeyLike, 二进制_:Binary }
    //@@{ 缓冲区_:Buffer }
    函数 私有加密(私有_密钥: Rsa私钥_ | 密钥族_, 缓冲区: 二进制_): 缓冲区_;

    //@@{ 公开解密:publicDecrypt, Rsa公钥_:RsaPublicKey, 密钥族_:KeyLike, 二进制_:Binary }
    //@@{ 缓冲区_:Buffer }
    函数 公开解密(公共_密钥: Rsa公钥_ | 密钥族_, 缓冲区: 二进制_): 缓冲区_;

    //@@{ 获取密码:getCiphers }
    函数 获取密码(): 文字[];

    //@@{ 获取曲线:getCurves }
    函数 获取曲线(): 文字[];

    //@@{ 获取哈希:getHashes }
    函数 获取哈希(): 文字[];
    类别 ECDH {
        私有 构造();

        //@@{ 转换键:convertKey }
        静态 转换键(

            //@@{ 二进制族_:BinaryLike }
            密钥: 二进制族_,
            曲线: 文字,

            //@@{ HexBase64编码_:HexBase64Latin1Encoding }
            输入字符编码?: HexBase64编码_,
            输出编码?: "latin1" | "hex" | "base64",

            //@@{ "未压缩":"uncompressed", "压缩":"compressed", "混合":"hybrid" }
            格式化?: "未压缩" | "压缩" | "混合",

        //@@{ 缓冲区_:Buffer }
        ): 缓冲区_ | 文字;

        //@@{ 生成密钥:generateKeys, 缓冲区_:Buffer }
        生成密钥(): 缓冲区_;

        //@@{ 生成密钥:generateKeys, HexBase64编码_:HexBase64Latin1Encoding, ECDH密钥格式_:ECDHKeyFormat }
        生成密钥(编码: HexBase64编码_, 格式化?: ECDH密钥格式_): 文字;

        //@@{ 计算共享密钥:computeSecret, 二进制_:Binary, 缓冲区_:Buffer }
        计算共享密钥(其他_公共_密钥: 二进制_): 缓冲区_;

        //@@{ 计算共享密钥:computeSecret, HexBase64编码_:HexBase64Latin1Encoding, 缓冲区_:Buffer }
        计算共享密钥(其他_公共_密钥: 文字, 输入_编码: HexBase64编码_): 缓冲区_;

        //@@{ 计算共享密钥:computeSecret, 二进制_:Binary, HexBase64编码_:HexBase64Latin1Encoding }
        计算共享密钥(其他_公共_密钥: 二进制_, 输出_编码: HexBase64编码_): 文字;

        //@@{ 计算共享密钥:computeSecret, HexBase64编码_:HexBase64Latin1Encoding }
        计算共享密钥(其他_公共_密钥: 文字, 输入_编码: HexBase64编码_, 输出_编码: HexBase64编码_): 文字;

        //@@{ 获取私钥:getPrivateKey, 缓冲区_:Buffer }
        获取私钥(): 缓冲区_;

        //@@{ 获取私钥:getPrivateKey, HexBase64编码_:HexBase64Latin1Encoding }
        获取私钥(编码: HexBase64编码_): 文字;

        //@@{ 获取公钥:getPublicKey, 缓冲区_:Buffer }
        获取公钥(): 缓冲区_;

        //@@{ 获取公钥:getPublicKey, HexBase64编码_:HexBase64Latin1Encoding, ECDH密钥格式_:ECDHKeyFormat }
        获取公钥(编码: HexBase64编码_, 格式化?: ECDH密钥格式_): 文字;

        //@@{ 设置私钥:setPrivateKey, 二进制_:Binary }
        设置私钥(私有_密钥: 二进制_): 无值;

        //@@{ 设置私钥:setPrivateKey, HexBase64编码_:HexBase64Latin1Encoding }
        设置私钥(私有_密钥: 文字, 编码: HexBase64编码_): 无值;
    }

    //@@{ 创建ECDH:createECDH }
    函数 创建ECDH(曲线_名字: 文字): ECDH;

    //@@{ 时间安全相等:timingSafeEqual, 二进制_:Binary }
    函数 时间安全相等(a: 二进制_, b: 二进制_): 真假;
    /** @deprecated since v10.0.0 */

    //@@{ __默认的_编码__:DEFAULT_ENCODING }
    常量 __默认的_编码__: 文字;

    //@@{ 密钥类型_:KeyType }
    导出 类型 密钥类型_ = 'rsa' | 'dsa' | 'ec';

    //@@{ 密钥格式化_:KeyFormat }
    导出 类型 密钥格式化_ = 'pem' | 'der';

    //@@{ 基本私钥编码选项_:BasePrivateKeyEncodingOptions, 密钥格式化_:KeyFormat }
    接口 基本私钥编码选项_<T 扩展 密钥格式化_> {

        //@@{ 格式化:format }
        格式化: T;

        //@@{ 密码:cipher }
        密码: 文字;

        //@@{ 口令:passphrase }
        口令: 文字;
    }

    //@@{ 密钥对密钥对象结果_:KeyPairKeyObjectResult }
    接口 密钥对密钥对象结果_ {

        //@@{ 公钥:publicKey, 密钥对象_:KeyObject }
        公钥: 密钥对象_;

        //@@{ 私钥:privateKey, 密钥对象_:KeyObject }
        私钥: 密钥对象_;
    }

    //@@{ EC密钥对密钥对象选项_:ECKeyPairKeyObjectOptions }
    接口 EC密钥对密钥对象选项_ {
        /**
         * Name of the curve to use.
         */

        //@@{ 命名的曲线:namedCurve }
        命名的曲线: 文字;
    }

    //@@{ RSA密钥对密钥对象选项_:RSAKeyPairKeyObjectOptions }
    接口 RSA密钥对密钥对象选项_ {
        /**
         * Key size in bits
         */

        //@@{ 模量长度:modulusLength }
        模量长度: 数字;

        /**
         * @default 0x10001
         */

        //@@{ 公共指数:publicExponent }
        公共指数?: 数字;
    }

    //@@{ DSA密钥对密钥对象选项_:DSAKeyPairKeyObjectOptions }
    接口 DSA密钥对密钥对象选项_ {
        /**
         * Key size in bits
         */

        //@@{ 模量长度:modulusLength }
        模量长度: 数字;

        /**
         * Size of q in bits
         */

        //@@{ 除数长度:divisorLength }
        除数长度: 数字;
    }

    //@@{ RSA键对选项_:RSAKeyPairOptions, 密钥格式化_:KeyFormat }
    接口 RSA键对选项_<PubF 扩展 密钥格式化_, PrivF 扩展 密钥格式化_> {
        /**
         * Key size in bits
         */

        //@@{ 模量长度:modulusLength }
        模量长度: 数字;
        /**
         * @default 0x10001
         */

        //@@{ 公共指数:publicExponent }
        公共指数?: 数字;

        //@@{ 公钥编码:publicKeyEncoding }
        公钥编码: {

            //@@{ 类型:type }
            类型: 'pkcs1' | 'spki';

            //@@{ 格式化:format }
            格式化: PubF;
        };

        //@@{ 私钥编码:privateKeyEncoding, 基本私钥编码选项_:BasePrivateKeyEncodingOptions }
        私钥编码: 基本私钥编码选项_<PrivF> & {

            //@@{ 类型:type }
            类型: 'pkcs1' | 'pkcs8';
        };
    }

    //@@{ DSA密钥对选项_:DSAKeyPairOptions, 密钥格式化_:KeyFormat }
    接口 DSA密钥对选项_<PubF 扩展 密钥格式化_, PrivF 扩展 密钥格式化_> {
        /**
         * Key size in bits
         */

        //@@{ 模量长度:modulusLength }
        模量长度: 数字;
        /**
         * Size of q in bits
         */

        //@@{ 除数长度:divisorLength }
        除数长度: 数字;

        //@@{ 公钥编码:publicKeyEncoding }
        公钥编码: {

            //@@{ 类型:type }
            类型: 'spki';

            //@@{ 格式化:format }
            格式化: PubF;
        };

        //@@{ 私钥编码:privateKeyEncoding, 基本私钥编码选项_:BasePrivateKeyEncodingOptions }
        私钥编码: 基本私钥编码选项_<PrivF> & {

            //@@{ 类型:type }
            类型: 'pkcs8';
        };
    }

    //@@{ EC密钥对选项_:ECKeyPairOptions, 密钥格式化_:KeyFormat }
    接口 EC密钥对选项_<PubF 扩展 密钥格式化_, PrivF 扩展 密钥格式化_> {
        /**
         * Name of the curve to use.
         */

        //@@{ 命名的曲线:namedCurve }
        命名的曲线: 文字;

        //@@{ 公钥编码:publicKeyEncoding }
        公钥编码: {

            //@@{ 类型:type }
            类型: 'pkcs1' | 'spki';

            //@@{ 格式化:format }
            格式化: PubF;
        };

        //@@{ 私钥编码:privateKeyEncoding, 基本私钥编码选项_:BasePrivateKeyEncodingOptions }
        私钥编码: 基本私钥编码选项_<PrivF> & {

            //@@{ 类型:type }
            类型: 'sec1' | 'pkcs8';
        };
    }

    //@@{ 密钥对同步结果_:KeyPairSyncResult, 缓冲区_:Buffer }
    接口 密钥对同步结果_<T1 扩展 文字 | 缓冲区_, T2 扩展 文字 | 缓冲区_> {

        //@@{ 公钥:publicKey }
        公钥: T1;

        //@@{ 私钥:privateKey }
        私钥: T2;
    }

    //@@{ 生成密钥对同步:generateKeyPairSync, RSA键对选项_:RSAKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    函数 生成密钥对同步(类型: 'rsa', 选项组: RSA键对选项_<'pem', 'pem'>): 密钥对同步结果_<文字, 文字>;

    //@@{ 生成密钥对同步:generateKeyPairSync, RSA键对选项_:RSAKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'rsa', 选项组: RSA键对选项_<'pem', 'der'>): 密钥对同步结果_<文字, 缓冲区_>;

    //@@{ 生成密钥对同步:generateKeyPairSync, RSA键对选项_:RSAKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'rsa', 选项组: RSA键对选项_<'der', 'pem'>): 密钥对同步结果_<缓冲区_, 文字>;

    //@@{ 生成密钥对同步:generateKeyPairSync, RSA键对选项_:RSAKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'rsa', 选项组: RSA键对选项_<'der', 'der'>): 密钥对同步结果_<缓冲区_, 缓冲区_>;

    //@@{ 生成密钥对同步:generateKeyPairSync, RSA密钥对密钥对象选项_:RSAKeyPairKeyObjectOptions }
    //@@{ 密钥对密钥对象结果_:KeyPairKeyObjectResult }
    函数 生成密钥对同步(类型: 'rsa', 选项组: RSA密钥对密钥对象选项_): 密钥对密钥对象结果_;

    //@@{ 生成密钥对同步:generateKeyPairSync, DSA密钥对选项_:DSAKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    函数 生成密钥对同步(类型: 'dsa', 选项组: DSA密钥对选项_<'pem', 'pem'>): 密钥对同步结果_<文字, 文字>;

    //@@{ 生成密钥对同步:generateKeyPairSync, DSA密钥对选项_:DSAKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'dsa', 选项组: DSA密钥对选项_<'pem', 'der'>): 密钥对同步结果_<文字, 缓冲区_>;

    //@@{ 生成密钥对同步:generateKeyPairSync, DSA密钥对选项_:DSAKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'dsa', 选项组: DSA密钥对选项_<'der', 'pem'>): 密钥对同步结果_<缓冲区_, 文字>;

    //@@{ 生成密钥对同步:generateKeyPairSync, DSA密钥对选项_:DSAKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'dsa', 选项组: DSA密钥对选项_<'der', 'der'>): 密钥对同步结果_<缓冲区_, 缓冲区_>;

    //@@{ 生成密钥对同步:generateKeyPairSync, DSA密钥对密钥对象选项_:DSAKeyPairKeyObjectOptions }
    //@@{ 密钥对密钥对象结果_:KeyPairKeyObjectResult }
    函数 生成密钥对同步(类型: 'dsa', 选项组: DSA密钥对密钥对象选项_): 密钥对密钥对象结果_;

    //@@{ 生成密钥对同步:generateKeyPairSync, EC密钥对选项_:ECKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    函数 生成密钥对同步(类型: 'ec', 选项组: EC密钥对选项_<'pem', 'pem'>): 密钥对同步结果_<文字, 文字>;

    //@@{ 生成密钥对同步:generateKeyPairSync, EC密钥对选项_:ECKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'ec', 选项组: EC密钥对选项_<'pem', 'der'>): 密钥对同步结果_<文字, 缓冲区_>;

    //@@{ 生成密钥对同步:generateKeyPairSync, EC密钥对选项_:ECKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'ec', 选项组: EC密钥对选项_<'der', 'pem'>): 密钥对同步结果_<缓冲区_, 文字>;

    //@@{ 生成密钥对同步:generateKeyPairSync, EC密钥对选项_:ECKeyPairOptions, 密钥对同步结果_:KeyPairSyncResult }
    //@@{ 缓冲区_:Buffer }
    函数 生成密钥对同步(类型: 'ec', 选项组: EC密钥对选项_<'der', 'der'>): 密钥对同步结果_<缓冲区_, 缓冲区_>;

    //@@{ 生成密钥对同步:generateKeyPairSync, EC密钥对密钥对象选项_:ECKeyPairKeyObjectOptions }
    //@@{ 密钥对密钥对象结果_:KeyPairKeyObjectResult }
    函数 生成密钥对同步(类型: 'ec', 选项组: EC密钥对密钥对象选项_): 密钥对密钥对象结果_;

    //@@{ 生成密钥对:generateKeyPair, RSA键对选项_:RSAKeyPairOptions, 错误_:Error }
    函数 生成密钥对(类型: 'rsa', 选项组: RSA键对选项_<'pem', 'pem'>, 回调: (错: 错误_ | 空值, 公钥: 文字, 私钥: 文字) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, RSA键对选项_:RSAKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'rsa', 选项组: RSA键对选项_<'pem', 'der'>, 回调: (错: 错误_ | 空值, 公钥: 文字, 私钥: 缓冲区_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, RSA键对选项_:RSAKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'rsa', 选项组: RSA键对选项_<'der', 'pem'>, 回调: (错: 错误_ | 空值, 公钥: 缓冲区_, 私钥: 文字) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, RSA键对选项_:RSAKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'rsa', 选项组: RSA键对选项_<'der', 'der'>, 回调: (错: 错误_ | 空值, 公钥: 缓冲区_, 私钥: 缓冲区_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, RSA密钥对密钥对象选项_:RSAKeyPairKeyObjectOptions }
    //@@{ 错误_:Error, 密钥对象_:KeyObject }
    函数 生成密钥对(类型: 'rsa', 选项组: RSA密钥对密钥对象选项_, 回调: (错: 错误_ | 空值, 公钥: 密钥对象_, 私钥: 密钥对象_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, DSA密钥对选项_:DSAKeyPairOptions, 错误_:Error }
    函数 生成密钥对(类型: 'dsa', 选项组: DSA密钥对选项_<'pem', 'pem'>, 回调: (错: 错误_ | 空值, 公钥: 文字, 私钥: 文字) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, DSA密钥对选项_:DSAKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'dsa', 选项组: DSA密钥对选项_<'pem', 'der'>, 回调: (错: 错误_ | 空值, 公钥: 文字, 私钥: 缓冲区_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, DSA密钥对选项_:DSAKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'dsa', 选项组: DSA密钥对选项_<'der', 'pem'>, 回调: (错: 错误_ | 空值, 公钥: 缓冲区_, 私钥: 文字) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, DSA密钥对选项_:DSAKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'dsa', 选项组: DSA密钥对选项_<'der', 'der'>, 回调: (错: 错误_ | 空值, 公钥: 缓冲区_, 私钥: 缓冲区_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, DSA密钥对密钥对象选项_:DSAKeyPairKeyObjectOptions }
    //@@{ 错误_:Error, 密钥对象_:KeyObject }
    函数 生成密钥对(类型: 'dsa', 选项组: DSA密钥对密钥对象选项_, 回调: (错: 错误_ | 空值, 公钥: 密钥对象_, 私钥: 密钥对象_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, EC密钥对选项_:ECKeyPairOptions, 错误_:Error }
    函数 生成密钥对(类型: 'ec', 选项组: EC密钥对选项_<'pem', 'pem'>, 回调: (错: 错误_ | 空值, 公钥: 文字, 私钥: 文字) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, EC密钥对选项_:ECKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'ec', 选项组: EC密钥对选项_<'pem', 'der'>, 回调: (错: 错误_ | 空值, 公钥: 文字, 私钥: 缓冲区_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, EC密钥对选项_:ECKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'ec', 选项组: EC密钥对选项_<'der', 'pem'>, 回调: (错: 错误_ | 空值, 公钥: 缓冲区_, 私钥: 文字) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, EC密钥对选项_:ECKeyPairOptions, 错误_:Error, 缓冲区_:Buffer }
    函数 生成密钥对(类型: 'ec', 选项组: EC密钥对选项_<'der', 'der'>, 回调: (错: 错误_ | 空值, 公钥: 缓冲区_, 私钥: 缓冲区_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair, EC密钥对密钥对象选项_:ECKeyPairKeyObjectOptions, 错误_:Error }
    //@@{ 密钥对象_:KeyObject }
    函数 生成密钥对(类型: 'ec', 选项组: EC密钥对密钥对象选项_, 回调: (错: 错误_ | 空值, 公钥: 密钥对象_, 私钥: 密钥对象_) => 无值): 无值;

    //@@{ 生成密钥对:generateKeyPair }
    名域 生成密钥对 {

        //@@{ __转为预设__:__promisify__, RSA键对选项_:RSAKeyPairOptions, 预设_:Promise, 公钥:publicKey }
        //@@{ 私钥:privateKey }
        函数 __转为预设__(类型: "rsa", 选项组: RSA键对选项_<'pem', 'pem'>): 预设_<{ 公钥: 文字, 私钥: 文字 }>;

        //@@{ __转为预设__:__promisify__, RSA键对选项_:RSAKeyPairOptions, 预设_:Promise, 公钥:publicKey }
        //@@{ 私钥:privateKey, 缓冲区_:Buffer }
        函数 __转为预设__(类型: "rsa", 选项组: RSA键对选项_<'pem', 'der'>): 预设_<{ 公钥: 文字, 私钥: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, RSA键对选项_:RSAKeyPairOptions, 预设_:Promise, 公钥:publicKey }
        //@@{ 缓冲区_:Buffer, 私钥:privateKey }
        函数 __转为预设__(类型: "rsa", 选项组: RSA键对选项_<'der', 'pem'>): 预设_<{ 公钥: 缓冲区_, 私钥: 文字 }>;

        //@@{ __转为预设__:__promisify__, RSA键对选项_:RSAKeyPairOptions, 预设_:Promise, 公钥:publicKey }
        //@@{ 缓冲区_:Buffer, 私钥:privateKey }
        函数 __转为预设__(类型: "rsa", 选项组: RSA键对选项_<'der', 'der'>): 预设_<{ 公钥: 缓冲区_, 私钥: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, RSA密钥对密钥对象选项_:RSAKeyPairKeyObjectOptions }
        //@@{ 预设_:Promise, 密钥对密钥对象结果_:KeyPairKeyObjectResult }
        函数 __转为预设__(类型: "rsa", 选项组: RSA密钥对密钥对象选项_): 预设_<密钥对密钥对象结果_>;

        //@@{ __转为预设__:__promisify__, DSA密钥对选项_:DSAKeyPairOptions, 预设_:Promise }
        //@@{ 公钥:publicKey, 私钥:privateKey }
        函数 __转为预设__(类型: "dsa", 选项组: DSA密钥对选项_<'pem', 'pem'>): 预设_<{ 公钥: 文字, 私钥: 文字 }>;

        //@@{ __转为预设__:__promisify__, DSA密钥对选项_:DSAKeyPairOptions, 预设_:Promise }
        //@@{ 公钥:publicKey, 私钥:privateKey, 缓冲区_:Buffer }
        函数 __转为预设__(类型: "dsa", 选项组: DSA密钥对选项_<'pem', 'der'>): 预设_<{ 公钥: 文字, 私钥: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, DSA密钥对选项_:DSAKeyPairOptions, 预设_:Promise }
        //@@{ 公钥:publicKey, 缓冲区_:Buffer, 私钥:privateKey }
        函数 __转为预设__(类型: "dsa", 选项组: DSA密钥对选项_<'der', 'pem'>): 预设_<{ 公钥: 缓冲区_, 私钥: 文字 }>;

        //@@{ __转为预设__:__promisify__, DSA密钥对选项_:DSAKeyPairOptions, 预设_:Promise }
        //@@{ 公钥:publicKey, 缓冲区_:Buffer, 私钥:privateKey }
        函数 __转为预设__(类型: "dsa", 选项组: DSA密钥对选项_<'der', 'der'>): 预设_<{ 公钥: 缓冲区_, 私钥: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, DSA密钥对密钥对象选项_:DSAKeyPairKeyObjectOptions }
        //@@{ 预设_:Promise, 密钥对密钥对象结果_:KeyPairKeyObjectResult }
        函数 __转为预设__(类型: "dsa", 选项组: DSA密钥对密钥对象选项_): 预设_<密钥对密钥对象结果_>;

        //@@{ __转为预设__:__promisify__, EC密钥对选项_:ECKeyPairOptions, 预设_:Promise, 公钥:publicKey }
        //@@{ 私钥:privateKey }
        函数 __转为预设__(类型: "ec", 选项组: EC密钥对选项_<'pem', 'pem'>): 预设_<{ 公钥: 文字, 私钥: 文字 }>;

        //@@{ __转为预设__:__promisify__, EC密钥对选项_:ECKeyPairOptions, 预设_:Promise, 公钥:publicKey }
        //@@{ 私钥:privateKey, 缓冲区_:Buffer }
        函数 __转为预设__(类型: "ec", 选项组: EC密钥对选项_<'pem', 'der'>): 预设_<{ 公钥: 文字, 私钥: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, EC密钥对选项_:ECKeyPairOptions, 预设_:Promise, 公钥:publicKey }
        //@@{ 缓冲区_:Buffer, 私钥:privateKey }
        函数 __转为预设__(类型: "ec", 选项组: EC密钥对选项_<'der', 'pem'>): 预设_<{ 公钥: 缓冲区_, 私钥: 文字 }>;

        //@@{ __转为预设__:__promisify__, EC密钥对选项_:ECKeyPairOptions, 预设_:Promise, 公钥:publicKey }
        //@@{ 缓冲区_:Buffer, 私钥:privateKey }
        函数 __转为预设__(类型: "ec", 选项组: EC密钥对选项_<'der', 'der'>): 预设_<{ 公钥: 缓冲区_, 私钥: 缓冲区_ }>;

        //@@{ __转为预设__:__promisify__, EC密钥对密钥对象选项_:ECKeyPairKeyObjectOptions }
        //@@{ 预设_:Promise, 密钥对密钥对象结果_:KeyPairKeyObjectResult }
        函数 __转为预设__(类型: "ec", 选项组: EC密钥对密钥对象选项_): 预设_<密钥对密钥对象结果_>;
    }
}
